Efficient cache utilization in a tiered data structure

ABSTRACT

A computer system detects a request to access a first data object stored in a tiered data structure that includes internal nodes and leaf nodes. In response to detecting the request, the computer system determines whether the first data object is stored in a cache that includes a plurality of data objects from the tiered data structure that are stored separately from their corresponding leaf node in the cache. When the first data object is stored in the cache, the computer system returns the first data object from the cache and when the first data object is not stored in the cache, the computer system traverses the tiered data structure to a leaf node that includes the first data object and returns the first data object from the leaf node for the first data object in the tiered data structure.

RELATED APPLICATIONS

This application claims priority to U.S. Provisional Application Ser. No. 61/973,170, filed Mar. 31, 2014, which is incorporated by reference herein in its entirety.

This application is also related to U.S. Provisional Patent Application No. 61/973,174, filed Mar. 31, 2014, U.S. Provisional Patent Application No. 61/973,177, filed Mar. 31, 2014, U.S. patent application Ser. No. 14/336,949, filed Jul. 21, 2014, and U.S. patent application Ser. No. 14/336,967, filed Jul. 21, 2014, all of which are hereby incorporated by reference in their entireties.

TECHNICAL FIELD

The disclosed embodiments relate generally to memory systems, and in particular, to improving the performance and efficiency of tiered data structures.

BACKGROUND

The speed of many computer operations is frequently constrained by the speed and efficiency with which data can be stored and retrieved from data structures associated with the device. Many conventional data structures take a long time to store and retrieve data. However, tiered data structures can be used to dramatically improve the speed and efficiency of data storage. Some tiered data structures enable data searches, data insertions, data deletions and sequential data access to be performed in logarithmic time. However, further improvements to tiered data structures can further increase the speed and efficiency with which data can be stored and retrieved, thereby improving the performance of computers relying on such tiered data structures.

SUMMARY

Various implementations of systems, methods and devices within the scope of the appended claims each have several aspects, no single one of which is solely responsible for the attributes described herein. Without limiting the scope of the appended claims, after considering this disclosure, and particularly after considering the section entitled “Detailed Description” one will understand how the aspects of various implementations are used to improve the performance and efficiency of tiered data structures.

BRIEF DESCRIPTION OF THE DRAWINGS

So that the present disclosure can be understood in greater detail, a more particular description may be had by reference to the features of various implementations, some of which are illustrated in the appended drawings. The appended drawings, however, merely illustrate the more pertinent features of the present disclosure and are therefore not to be considered limiting, for the description may admit to other effective features.

FIG. 1 is a block diagram illustrating an implementation of a data storage system, in accordance with some embodiments.

FIG. 2 is a block diagram illustrating an implementation of a computer system, in accordance with some embodiments.

FIGS. 3A-3F illustrate an example of a tiered data structure and example operations performed with the example tiered data structure, in accordance with some embodiments.

FIGS. 4A-4E illustrate a method of efficient cache utilization in a tiered data structure, in accordance with some embodiments.

FIGS. 5A-5C illustrate a method of performing conditional updates for reducing frequency of data modification operations (e.g., in a tiered data structure), in accordance with some embodiments.

FIGS. 6A-6D illustrate a method of compaction of information in a tiered data structure, in accordance with some embodiments.

In accordance with common practice the various features illustrated in the drawings may not be drawn to scale. Accordingly, the dimensions of the various features may be arbitrarily expanded or reduced for clarity. In addition, some of the drawings may not depict all of the components of a given system, method or device. Finally, like reference numerals may be used to denote like features throughout the specification and figures.

DETAILED DESCRIPTION

The various implementations described herein include systems, methods and/or devices used to improve the performance and efficiency of tiered data structures. One or more of the various implementations described herein include systems, methods and/or devices for efficient cache utilization in a tiered data structure. One or more of the various implementations described herein include systems, methods and/or devices for performing conditional updates for reducing frequency of data modification operations (e.g., in a tiered data structure). One or more of the various implementations described herein include systems, methods and/or devices for compaction of information in a tiered data structure.

Numerous details are described herein in order to provide a thorough understanding of the example implementations illustrated in the accompanying drawings. However, some embodiments may be practiced without many of the specific details, and the scope of the claims is only limited by those features and aspects specifically recited in the claims. Furthermore, well-known methods, components, and circuits have not been described in exhaustive detail so as not to unnecessarily obscure more pertinent aspects of the implementations described herein.

As described in more detail below, a computer system detects a request to access a first data object stored in a tiered data structure that includes internal nodes and leaf nodes. In response to detecting the request, the computer system determines whether the first data object is stored in a cache that includes a plurality of data objects from the tiered data structure that are stored separately from their corresponding leaf node in the cache. When the first data object is stored in the cache, the computer system returns the first data object from the cache and when the first data object is not stored in the cache, the computer system traverses the tiered data structure to a leaf node that includes the first data object and returns the first data object from the leaf node for the first data object in the tiered data structure.

In some embodiments, returning the first data object from the cache to the requestor includes locating the first data object in the cache using a hash table to map a unique key of the first data object that is included with the request to a portion of the cache that includes the first data object. In some embodiments, returning the first data object from the cache to the requestor includes locating the first data object in the cache without reference to the tiered data structure.

In some embodiments, two or more of the leaf nodes each include multiple data objects, each of the data objects including unique key information and a corresponding value.

In some embodiments, the cache is stored in high-speed memory, and the tiered data structure is stored in persistent memory (e.g., NAND flash memory or other non-volatile memory) that has a slower average read and/or write speed than the high-speed memory. In some embodiments, the persistent memory comprises one or more three-dimensional (3D) memory devices and circuitry associated with operation of memory elements in the one or more 3D memory devices. In some embodiments, the circuitry and one or more memory elements in a respective 3D memory device, of the one or more 3D memory devices, are on the same substrate (e.g., a silicon substrate).

In some embodiments, in accordance with a determination that the first data object is not stored in the cache, after returning the first data object from the leaf node for the first data object, the computer system stores the first data object in the cache.

In some embodiments, in conjunction with storing the first data object in the cache, in accordance with a determination that cache eviction criteria have been met, the computer system evicts one or more other data objects from the cache.

In some embodiments, in conjunction with traversing the tiered data structure to the leaf node for the first data object, the computer system caches internal nodes that are traversed between a root node and the leaf node for the first data object. In some embodiments, traversing the tiered data structure to the leaf node for the first data object includes retrieving one or more nodes that were previously cached during previous traversals of the tiered data structure. In some embodiments, the cache is populated with data objects retrieved by traversing the tiered data structure in response to prior requests to access data objects from the tiered data structure.

In some embodiments, a method performed by the computer system includes detecting an insert request to insert a second data object into the tiered data structure, and in response to detecting the insert request, (A) traversing the tiered data structure to a leaf node for the second data object and inserting the second data object into the leaf node for the second data object, and (B) in accordance with a determination that the second data object was successfully inserted into the tiered data structure, storing the second data object in the cache separately from the leaf node for the second data object.

In some embodiments, a method performed by the computer system includes detecting an update request to update a third data object in the tiered data structure, and in response to detecting the update request, (A) traversing the tiered data structure to a leaf node for the third data object and updating the third data object in the leaf node for the third data object, and (B) in accordance with a determination that the third data object was successfully updated in the tiered data structure, storing the updated third object in the cache separately from the leaf node for the third data object.

In some embodiments, a method performed by the computer system includes detecting a delete request to delete a fourth data object in the tiered data structure, and in response to detecting the delete request, (A) traversing the tiered data structure to a leaf node for the fourth data object and deleting the fourth data object from the leaf node for the fourth data object, and (B) in accordance with a determination that the fourth data object was successfully deleted in the tiered data structure and is stored in the cache, deleting the fourth object from the cache.

In some embodiments, the cache has a predefined size, and at a respective point in time, the cache is populated with recently accessed data objects for a plurality of leaf nodes; and the predefined size of the cache is smaller than the aggregate size of the plurality of leaf nodes. For example, in some circumstances, the respective point in time is a point in time after one or more data objects have been evicted from the cache.

In some embodiments, the cache has a data object portion for storing data objects separately from their corresponding leaf nodes and a node portion for storing leaf nodes and internal nodes of the tiered data structure. In some of these embodiments, a method performed by the computer system includes, in conjunction with returning the first data object from the leaf node for the first data object in the tiered data structure to the requestor, caching the first data object in the data object portion of the cache, and caching the leaf node for the first data object in the node portion of the cache. Furthermore, the method includes, after caching the first data object and the leaf node for the first data object, accessing a different data object in a different leaf node of the tiered data structure, and in conjunction with accessing the different data object, caching the different data object in the data object portion of the cache while maintaining the first data object in the data object portion of the cache, and caching the different leaf node in the node portion of the cache and evicting the leaf node for the first data object from the node portion of the cache.

FIG. 1 is a block diagram illustrating an implementation of a data storage system 101, in accordance with some embodiments. While some example features are illustrated, various other features have not been illustrated for the sake of brevity and so as not to obscure more pertinent aspects of the example implementations disclosed herein. To that end, as a non-limiting example, data storage system 101 includes computer system 102, tiered data structure 104, cache 106, and one or more internal requestors 108 (e.g., processes or applications that are internal to data storage system 101). While internal requestor 108 is shown as separate from computer system 102 in FIG. 1, in some circumstances internal requestor 108 is a processor application that is co-resident with data access processes on the computer system 102. In some embodiments, cache 106 is divided into a data object cache portion 106-1 for storing data objects retrieved from tiered data structure 104 and node cache portion 106-2 for storing nodes retrieved from tiered data structure 104. In some embodiments, there is a separate data object cache 106-1 that is distinct from node cache 106-2. While cache 106 is shown as separate from computer system 102 in FIG. 1, in some circumstances cache 106 is stored in memory of computer system 102.

In some embodiments, tiered data structure 104 is stored in non-volatile memory such as NAND-type flash memory or NOR-type flash memory, magnetic hard disk drives or other persistent storage medium that maintains its state when power is removed. In some embodiments, cache 106 is stored in RAM or other random access memory that is not persistent and does not maintain its state when power is removed. In some embodiments, tiered data structure 104 is divided across a plurality of storage devices. Computer system 102 responds to requests from internal requestors 108 (e.g., other computer systems or components of data storage system 101 that need access to data stored in tiered data structure 104) and/or external requestors 110 by storing, retrieving, and modifying data in tiered data structure 104 and cache 106, as described in greater detail below with reference to FIGS. 4A-4E, 5A-5C, and 6A-6D

FIG. 2 is a block diagram illustrating an implementation of a computer system 102, in accordance with some embodiments. Computer system 102 typically includes one or more processors (also sometimes called CPUs or processing units or microprocessors or microcontrollers) 202 for executing modules, programs and/or instructions stored in memory 206 and thereby performing processing operations, memory 206, and one or more communication buses 208 for interconnecting these components. Communication buses 208 optionally include circuitry (sometimes called a chipset) that interconnects and controls communications between system components. In some embodiments, computer system 102 is coupled to tiered data structure 104, and cache 106 (optionally including data object cache portion 106-1 and node cache portion 106-2) by communication buses 208 and storage interface(s) 210 (e.g., an input output, I/O, interface such as a PCI bus or PCIe bus). In some embodiments, computer system 102 is coupled to internal requestor(s) 108 and/or external requestors 110 by communication buses 208 and requestor interface(s) 212. Memory 206 includes high-speed random access memory, such as DRAM, SRAM, DDR RAM or other random access solid state memory devices, and may include non-volatile memory, such as one or more magnetic disk storage devices, optical disk storage devices, flash memory devices, or other non-volatile solid state storage devices. Memory 206 optionally includes one or more storage devices remotely located from processor(s) 202. Memory 206, or alternately the non-volatile memory device(s) within memory 206, comprises a non-transitory computer readable storage medium. In some embodiments, memory 206, or the computer readable storage medium of memory 206 stores the following programs, modules, and data structures, or a subset thereof:

-   -   operating logic 220 includes procedures for handling various         basic system services and for performing hardware dependent         tasks;     -   communications module 222 that is used for communicating with         other computer systems or computer components (e.g., via storage         interface(s) 210 and requestor interface(s) 212);     -   request module 224 for detecting and processing request received         from internal requestors 108 (FIG. 1) and external requestors         110 (FIG. 1);     -   cache module 226 for storing and retrieving information (e.g.,         data objects and nodes) from cache 106, optionally including:         -   cache storage module 228 for storing information (e.g., data             objects and nodes) in cache 106;         -   cache search module 230 for performing searches based on             requested information (e.g., a search for a requested data             object or retrieving a node for use in searching for a             requested data object) in cache 106; and         -   cache eviction policies 232 for determining which             information (e.g., data objects and/or nodes) to evict from             cache 106;     -   tiered data structure module 234 for storing and retrieving         information (e.g., data objects and nodes) within tiered data         structure 104, optionally including:         -   tiered data structure storage module 236 for storing             information (e.g., new data objects or updated data objects)             in leaf nodes of tiered data structure 104 and/or deleting             information from tiered data structure 104;         -   tiered data structure search module 238 for searching             through tiered data structure 104 for requested data (e.g.,             one or more data objects requested by a requestor);         -   metadata generator 240 for generating metadata for data             objects that is stored in leaf nodes of tiered data             structure 104 with the data objects and enables the data             objects to be located with tiered data structure search             module 238 in response to requests from requestors; and         -   conditional update module 242 for locking portions of tiered             data structure 104 while a conditional update operation is             being performed so as to improve the efficiency of the             conditional update operation;     -   response generator 224 for generating responses to requests from         internal and external requestors based on data retrieved in         response to the requests; and     -   optionally, one or more internal requestors 108 for requesting         data objects from tiered data structure 104 and/or cache 106.

Each of the above identified elements may be stored in one or more of the previously mentioned memory devices, and corresponds to a set of instructions for performing a function described above. The above identified modules or programs (i.e., sets of instructions) need not be implemented as separate software programs, procedures or modules, and thus various subsets of these modules may be combined or otherwise re-arranged in various embodiments. In some embodiments, memory 206 may store a subset of the modules and data structures identified above. Furthermore, memory 206 may store additional modules and data structures not described above. In some embodiments, the programs, modules, and data structures stored in memory 206, or the computer readable storage medium of memory 206, provide instructions for implementing respective operations in the methods described below with reference to FIGS. 4A-4E, 5A-5C, and/or 6A-6D.

Although FIG. 2 shows a computer system 102, FIG. 2 is intended more as a functional description of the various features which may be present in a non-volatile computer system than as a structural schematic of the embodiments described herein. In practice, and as recognized by those of ordinary skill in the art, items shown separately could be combined and some items could be separated.

FIG. 3A illustrates an example of a tiered data structure, in accordance with some embodiments. Tiered data structure 104 includes a plurality of nodes. The plurality of nodes are organized in a tiered structure in which each respective node is connected to one or more other nodes in levels (tiers) above and/or below the respective node. A parent node for a respective node in tiered data structure 104 is a node that is a level (tier) above the respective node in tiered data structure 104 and refers to the respective node. A child node for a respective node in tiered data structure 104 is a node that is a level (tier) below the respective node in tiered data structure 104 and refers to the respective node. Two nodes are at the same level if they have a same number of nodes to traverse to reach root node 302. Root node 302 is an external node that has no parent node, typically there is only one root node for tiered data structure 104. Internal nodes 304 are nodes that have both a parent node and one or more child nodes and are thus internal to the tiered data structure. Leaf nodes 306 are nodes that do not have child nodes and are thus “external” nodes. Root node 302 and internal nodes 304 include references that indicate which child nodes are associated with a particular range of data. For example, root node 302 in FIG. 3A indicates that internal node 304-1 is associated with data with keys between 1 and 136. Internal node 304-1 indicates that: internal node 304-2 is associated with data objects having keys between 1 and 24; internal node 304-3 is associated with data objects having keys between 25 and 66; and internal node 304-4 is associated with data objects having keys between 67 and 136. Similarly, internal node 304-3 indicates that: leaf node 306-2 includes data with keys between 25 and 30; leaf node 306-3 includes data with keys between 31 and 58; and leaf node 306-4 includes data with keys between 59 and 66, and so on.

Navigating the tiered data structure typically, but optionally, relies on the assumption that keys are always sorted in a predefined order (e.g., monotonically ascending), so that a node that is associated with data having keys between a first value and a second value is associated with all data in the tiered data structure that has keys between the first value and the second value. In some embodiments, each leaf node has a maximum size and when the leaf node exceeds the maximum size, the leaf node is split into two leaf nodes. In some embodiments, each leaf node has a minimum size and when a leaf node is below the minimum size, the leaf node is combined with one or more other leaf nodes. In some embodiments, each non-leaf node (e.g., root node or internal node) has a maximum number of child nodes, and when a splitting a leaf node results in a non-leaf node having more than the maximum number of child nodes, the non-leaf node is split to accommodate the extra child nodes. In some embodiments, each non-leaf node (e.g., root node or internal node) has a minimum number of child nodes, and when a combining two or more leaf nodes results in a non-leaf node having less than the minimum number of child nodes, the non-leaf node is combined with one or more other non-leaf nodes to accommodate the reduced number of child nodes. The tiered data structure may additionally conform to some or all of the rules associated with B-Trees, B+Trees, B*Trees or other tiered data structures.

FIG. 3B illustrates an example of efficient cache utilization in a tiered data structure, in accordance with some embodiments. In FIG. 3B, populated cache 310-a is an example of cache 106 from FIGS. 1 and 2 that is populated with one or more data objects and one or more nodes that were retrieved to respond to prior requests for data objects by one or more internal or external requestors. For example, one of the prior requests was a request for data object 58, so computer system 102 traversed through tiered data structure 104 in FIG. 3A by traversing, in sequence, root node 302, internal node 304-1, internal node 304-3 to identify and retrieve leaf node 306-3, which includes data object 58. After retrieving data object 58, data object 58 is cached in data object cache portion 106-1 and the traversed nodes are cached in node cache portion 106-2. In FIG. 3B, the data objects in the populated cache 310 are shown in order of “staleness” where more stale data objects are near the bottom of data object cache portion 106-1 and less stale (e.g., fresher) data objects are near the top of data object cache portion 106-1, as data objects are refreshed, they are reordered in the cache to represent their staleness, even though the data objects are, in many circumstances, not actually moved within the cache. Similarly, in FIG. 3B, the nodes in the populated cache 310 are shown in order of “staleness” where more stale nodes are near the bottom of node cache portion 106-2 and less stale (e.g., fresher) data objects are near the top of node cache portion 106-2, as nodes are refreshed, they are reordered in the cache to represent their staleness, even though nodes are, in many circumstances, not actually moved within the cache.

In FIG. 3B, in response to a request (e.g., “request 1”) for data object 61, computer system 102 determines that data object 61 is not in data object cache portion 106-1 in populated cache 310-a. Subsequently, computer system 102 traverses through tiered data structure 104 in FIG. 3A by traversing, in sequence, root node 302, internal node 304-1, internal node 304-3 to identify and retrieve leaf node 306-4, which includes data object 61. When traversing tiered data structure 104, computer system 102 is able to use a number of cached nodes to improve response time (e.g., by using root node 302, internal node 304-1 and internal node 304-3 to determine that leaf node 306-4 has be retrieved from tiered data structure 104). Computer system 102 caches the traversed nodes in node cache portion 106-2 and caches data object 61 in data object cache portion 106-1 as shown in updated cache 310-b in FIG. 3B. In order to make room for the traversed nodes and retrieved data object, data object 2 and leaf node 306-1 are evicted from cache 106 in accordance with a cache eviction policy, as shown in updated cache 310-b in FIG. 3B.

In FIG. 3B, in response to a request (e.g., “request 2”) for data object 25, computer system 102 determines that data object 25 is in data object cache portion 106-1 in populated cache 310-b. As data object 25 is already in data object cache portion 106-1, computer system 102 does not traverse tiered data structure 104 to retrieve data object 25, because data object 25 is retrieved from cache 106. In conjunction with being retrieved, data object 25 is refreshed in data object cache portion 106-1 so that it is less stale than object 61 rather than being more stale than data object 61, as shown in updated cache 310-c in FIG. 3B. In some embodiments, data object 25 is identified in data object cache portion 106-1 using a hash table to locate a portion of data object cache portion 106-1 that includes data object 25. As no new data objects or nodes were added to cache 106, no data objects or nodes are evicted from cache 106.

In FIG. 3B, in response to a request (e.g., “request 3”) for data object 70, computer system 102 determines that data object 70 is not in data object cache portion 106-1 in populated cache 310-c. Subsequently, computer system 102 traverses through tiered data structure 104 in FIG. 3A by traversing, in sequence, root node 302, internal node 304-1, internal node 304-4 to identify and retrieve leaf node 306-5, which includes data object 70. When traversing tiered data structure 104, computer system 102 is able to use a number of cached nodes to improve response time (e.g., by using root node 302 and internal node 304-1 to determine that internal node 304-4 and leaf node 306-5 have to be retrieved from tiered data structure 104). Computer system 102 caches the traversed nodes in node cache portion 106-2 and caches data object 70 in data object cache portion 106-1 as shown in updated cache 310-d in FIG. 3B. In order to make room for the traversed nodes and retrieved data object, data object 33, internal node 304-3, and leaf node 306-3 are evicted from cache 106 in accordance with a cache eviction policy, as shown in updated cache 310-d in FIG. 3B.

While the preceding examples have been shown with a small number of data objects and nodes, it should be understood that in a typical cache, a much larger number of data objects and nodes are stored in the cache and similar processes are performed. For example in an 2 GB (gigabyte) DRAM cache with a 1 GB data object cache portion, a 1 gigabyte node cache portion, an average node size of 8 KB (kilobytes) and an average data object size of 1 KB, the data object cache portion would hold approximately 1 million data objects and the node cache portion would hold approximately 250,000 nodes. In some embodiments, only internal nodes 304 are cached in node cache portion 106-2. In some embodiments, root node 302 and leaf nodes 306 are cached in node cache portion 106-2, but most leaf nodes are quickly evicted from node cache portion 106-2, while internal nodes 304 are frequently used and are thus frequently refreshed in cache 106, so that the node cache portion 106-2 includes primarily internal nodes 304 during normal operation (e.g., 50% or more of the capacity of node cache portion 106-2 is occupied by internal nodes). Using a data object cache in addition to a node cache instead of solely using a node cache improves the performance of the cache by increasing the likelihood that a requested data object will be available from the cache. For example, using a 1 GB data object cache in addition to a 1 GB node cache approximately quadruples the object capacity of the cache as compared with a 2 GB node cache. Additional details regarding efficient cache utilization in a tiered data structure are described below with reference to method 400 and FIGS. 4A-4E.

FIG. 3C illustrates an example of performing conditional updates for reducing frequency of traversals (e.g., in a tiered data structure), in accordance with some embodiments. In FIG. 3C, computer system 102 (FIGS. 1 and 2) detects (320) a request, received from an internal requestor or an external requestor, to access one or more data objects (e.g., data object 59, which is in leaf node 306-4). In some circumstances, when the request is detected, tiered data structure 104 does not have any nodes locked (e.g., read locked or read/write locked) by computer system 102. Although, in some circumstances one or more other computer systems using the same tiered data structure optionally lock one or more of the nodes of tiered data structure 104 when they are using those nodes. Assuming that the requested data object(s) are not available in a cache (e.g., as described above with reference to FIG. 3B), computer system 102 traverses (322) tiered data structure 104, as shown in FIG. 3C, to reach the node (e.g., leaf node 306-4) that includes the requested data object(s) (e.g., data object 59).

After identifying the leaf node that includes the requested data object, computer system 102 locks (323) the leaf node that includes the requested data object, as shown in FIG. 5C, where leaf node 306-4 is locked, and performs one or more additional operation (e.g., operations 324-326), while the leaf node is locked (e.g., read or read/write locked). After locking the leaf node, computer system 102 transmits (324) a conditional-update communication to a requestor, detects (325) a constitutional update response, and performs (326) one or more operations based on the conditional update response. For example, computer system 102 performs a conditional write operation where the requestor decides whether or not to perform the write operation based on the current value of the data object. As another example, computer system 102 performs a read-modify-write operation by returning a current value of the data object to the requestor in the conditional-update communication. Other examples of conditional update operations include “fetch and op” operations and “compare and swap” operations. In circumstances where the condition for the conditional update operation is not met, then the operation performed based on the conditional-update response optionally includes deciding not to perform any update on the requested data object.

In some circumstances, the detected request (e.g., detected in operation 320) includes a request to access multiple data objects that are in a single leaf node, in which case operations 324-326 are, optionally, repeated for two or more of the multiple data objects, so as to reduce the number of traversals of tiered data structure 104. After the operation(s) based on the conditional-update response have been performed, computer system 102 unlocks (328) the leaf node (e.g., leaf node 306-4) that was locked in response to the request to access the requested data object. Additional details regarding performing conditional updates for reducing frequency of data modification operations (e.g., in a tiered data structure) are described below with reference to method 500 and FIGS. 5A-5C.

FIGS. 3D-3F illustrate examples of compaction of information in a tiered data structure, in accordance with some embodiments. FIG. 3C shows an example leaf node 306-4 from tiered data structure 104 in FIG. 3A. Leaf node 306-4 includes data for data objects 59, 60, 61, 63 and 66. For each of these data objects (e.g., D059, D060, D061, D063, D066), leaf node 306-4 includes a corresponding fixed length header (H59, H60, H61, H63, and H66, respectively) and corresponding metadata (e.g., M59, M60, M61, M63, and M66, respectively). The fixed length headers include a metadata type in embodiments where there are a plurality of different metadata types for metadata of the data objects, and an offset (e.g., a number of bytes) from a particular portion of the leaf node (e.g., a beginning or an end of the leaf node) to the location of the data object in the leaf node. The fixed length headers each have the same length, and can, thus, be used to perform a binary search through data objects in the leaf node. In some embodiments, the fixed length headers are packed to the left in the leaf node and the data objects and metadata are packed to the right in the leaf node, so that there is a growing area in the middle of the leaf node that increases or decreases in size as additional data objects are added to, or removed from, the leaf node. Packing the headers and data objects in different directions enables both the headers and the data objects to have fixed points to refer to when the data objects and nodes are identified by offsets (e.g., the headers can be identified based on an offset from a left edge of the leaf node, and the data objects and metadata can be identified based on an offset from a right edge of the leaf node).

The data objects (e.g., D059, D060, D061, D063, D066) in leaf node 306-4 each include unique key information (e.g., K59, K60, K61, K63, K66, respectively) and a corresponding value (e.g., V59, V60, V61, V63, V66, respectively). In some embodiments, the unique key information for some of the data objects is a full unique key for the data objects, while the unique key information for other data objects is a portion of a unique key for the data objects, and the metadata for these data objects indicates a location of a key prefix that is shared with one or more other data objects that can be used to recreate the unique key for the data object in combination with the unique key information stored with the data object. For example, data object 59 includes a full unique key in unique key information K59, while data object 60 includes a partial key in unique key information K60 and metadata M60 associated with data object 60 is used to identify a location of a key prefix (e.g., a portion of K59 that serves as a key prefix for data object 60 and, in combination with unique key information K60 can be used to determine a unique key for data object 60). Similarly, data object 61 includes a partial key in unique key information K61 and metadata M61 associated with data object 61 is used to identify a location of a key prefix (e.g., a portion of K59 that serves as a key prefix for data object 61 and, in combination with unique key information K61 can be used to determine a unique key for data object 61).

Metadata (e.g., M59, M60, M61, M63, and M66) for a corresponding data object optionally includes one or more of the following: key length information 334 indicating a length of unique key information associated with the corresponding data object; data length information 336 indicating a length of the corresponding data object or the value of the corresponding data object; prefix offset information 338 that indicates a location of a start of a key prefix for the corresponding data object; prefix length information 340 that indicates a length of the key prefix for the corresponding data object; data overflow pointer 342 that indicates a location of data for the corresponding data object that is too large to fit in the leaf node; and global version information 344 that indicates a version of the corresponding data object. In some embodiments, the global version information 344 includes information identifying the order of each change to data objects in tiered data structure 104 (FIGS. 1 and 2) or data objects in data storage system 101 (FIGS. 1 and 2), which can be used to determine whether a change to a first data object occurred before or after a change to a second, different, data object.

In some embodiments different data objects have different types of metadata with different lengths, sometimes called variable-length metadata. Using variable length metadata enables shorter metadata to be used in many situations, and using shorter metadata increases the number of data objects that can be stored in a leaf node. As one example, there are four types of metadata, type-0 metadata, type-1 metadata, type-2 metadata and type-3 metadata. Type-0 metadata is used when the data object has the same key prefix, key length, and data length as the preceding data object, in which case the metadata includes only global version information 344 (e.g., represented as a 64-bit unsigned integer), and other information such as key prefix location, data length and key length are determined by looking at the metadata corresponding to the preceding data object. Type-1 metadata is used when the data object has a key length and data length that can each fit in a single byte and data that fits in the leaf node, in which case the metadata includes key length information 334 (e.g., represented as an 8-bit unsigned integer), data length information 336 (e.g., represented as an 8-bit unsigned integer), prefix offset information 338 (e.g., represented as an 16-bit unsigned integer), prefix length information 340 (e.g., represented as an 8-bit unsigned integer), and global version information 344 (e.g., represented as a 64-bit unsigned integer). Type-2 metadata is used when the data object has a key length and data length that can each fit in two bytes, in which case the metadata includes key length information 334 (e.g., represented as an 16-bit unsigned integer), data length information 336 (e.g., represented as an 16-bit unsigned integer), prefix offset information 338 (e.g., represented as an 16-bit unsigned integer), prefix length information 340 (e.g., represented as an 16-bit unsigned integer), data overflow pointer 342 (e.g., represented as a 64-bit unsigned integer), and global version information 344 (e.g., represented as a 64-bit unsigned integer). Type-3 metadata is used for data objects that do not fit in the other categories, in which case the metadata includes key length information 334 (e.g., represented as an 32-bit unsigned integer), data length information 336 (e.g., represented as an 32-bit unsigned integer), prefix offset information 338 (e.g., represented as an 16-bit unsigned integer), prefix length information 340 (e.g., represented as an 32-bit unsigned integer), data overflow pointer 342 (e.g., represented as a 64-bit unsigned integer), and global version information 344 (e.g., represented as a 64-bit unsigned integer). Type-3 metadata is the most flexible metadata type, but is also the largest of these four metadata types. Enabling the use of other types of metadata (e.g., type-0, type-1, and type-2) saves space in the leaf node when type-3 metadata is not needed to store all of the relevant metadata for a data object. While the example above describes four types of metadata, the principles described above (e.g., using a shorter formats for metadata where the shorter format enables all of the necessary metadata information to be conveyed by the shorter metadata) would apply equally to other types of metadata and thus, in principle, any number of types of metadata could be used in an analogous manner.

FIG. 3E shows an example, of deleting a data object from leaf node 306-4. In the upper part of FIG. 3E, before data object 63 has been deleted, leaf node 306-4 is shown with highlighting in black to indicate the information in leaf node 306-4 that will be deleted when the deletion operation is performed. After data object 63 has been deleted, header H63 is deleted from leaf node 306-4, as shown in the lower part of FIG. 3E, and the remaining headers (e.g., H59, H60, H61, and H66) are repacked against the left edge of leaf node 306-4. Additionally, after data object 63 has been deleted, data object D063 and corresponding metadata M63 are deleted as shown in the lower part of FIG. 3E, and the remaining data objects (e.g., D059, D060, D061, and D066) and metadata (e.g., M59, M60, M61, and M66) are repacked against the right edge of leaf node 306-4. Additionally, before data object 63 was deleted, data object 66 relied on a portion of the key of data object 63 as a key prefix for data object 66. Thus, after data object 63 and its corresponding unique key information K63 is deleted, data object 66 can no longer rely on the portion of the key of data object 63 as a key prefix. Thus, in FIG. 3E, unique key information K66 for data object 66 is updated to include a full unique key for data object 66, and metadata M66 is updated to include a null value for the prefix offset information to indicate that there is no key prefix for data object 66 and that the unique key information K66 for data object 66 includes a full unique key. Alternatively, in some circumstances, computer system 102 determines that there is another data object (e.g., data object 59) in leaf node 306-4 that is associated with unique key information that could be used as a new key prefix for data object 66, and unique key information K66 is updated to include a portion of the unique key for data object 66 that, when combined with the new key prefix can be used to generate the full unique key for data object 66, and metadata M66 is updated to point to unique key information (e.g., K59) for the other data object so that a portion of unique key information (e.g., K59) for the other data object can be used as a key prefix for data object 66. Additionally, in many circumstances, repacking the data objects and headers as described above after deleting data object 63 will change locations of data objects, metadata and headers relative to the locations from which offsets identifying locations of these elements are measured, and thus after a data object, header, and metadata have been deleted, computer system 102 updates the offset information in the header and metadata corresponding to one or more of the other data objects (e.g., data objects that remain in leaf node 306-4 after to deleting data object 63).

FIG. 3F shows an example, of adding a data object from leaf node 306-4. In the upper part of FIG. 3F, before data object 65 has been added, leaf node 306-4 is shown with data object D065 that is to be added to leaf node 306-4. After data object 65 has been added, new header H65 is added in between header H63 and header H66, as shown in the lower part of FIG. 3F, and the headers (e.g., H59, H60, H61, H63, H65, and H66) are repacked against the left edge of leaf node 306-4. Additionally, after data object 65 has been added, data object D065 and corresponding metadata M65 are added to leaf node 306-4 as shown in the lower part of FIG. 3F, and the data objects (e.g., D059, D060, D061, D063, D065, and D066) and metadata (e.g., M59, M60, M61, M63, M65, and M66) are repacked against the right edge of leaf node 306-4. Additionally, before data object 65 was added, data object 66 relied on a portion of the key of data object 63 as a key prefix for data object 66 and data object 63 was adjacent to metadata M66 for data object 66. Thus, after data object 65 is added in between data object 63 and data object 66, metadata M66 of data object 66 is updated to indicate a different offset for the key prefix for data object 66, because the relative position between metadata M66 and unique key information K63 has changed. Moreover, in FIG. 3F, newly added data object 65 is also able to use a portion of unique key information K63 as a key prefix, and thus metadata M65 of data object 65 is updated to identify a portion of K63 as a key prefix that can be combined with unique key information K65 to generate a full unique key for data object 65. Additionally, in many circumstances, repacking the data objects and headers as described above after adding data object 65 will change locations of data objects, metadata and headers relative to the locations from which offsets identifying locations of these elements are measured, and thus after a new data object, new header and new metadata have been inserted, computer system 102 updates the offset information in the header and metadata corresponding to one or more of the other data objects (e.g., data objects that were in leaf node 306-4 prior to adding data object 65).

In some situations one or more data objects are updated without adding or deleting a data object from leaf node 306-4. However, even though a data object has not been added or deleted, updating a data object will, in some circumstances change a size of the data object (e.g., by changing a type of metadata used by the data object to a smaller or larger size of metadata or by changing a length of the data to a smaller or larger length). The change in the data object or associated metadata will, in many circumstances, change locations of data objects, metadata and headers relative to the locations from which offsets identifying locations of these elements are measured, and thus after a data object or metadata has been updated, computer system 102 updates the offset information in the header and metadata corresponding to one or more of the other data objects. Additional details regarding compaction of information in a tiered data structure are described below with reference to method 600 and FIGS. 6A-6D.

Attention is now directed to FIGS. 4A-4E, which illustrate a method 400 for efficient cache utilization in a tiered data structure, in accordance with some embodiments. Method 400 is, optionally, governed by instructions that are stored in a non-transitory computer readable storage medium and that are executed by one or more processors of one or more computer systems (e.g., computer system 102, FIG. 2). Each of the operations shown in FIGS. 4A-4E typically corresponds to instructions stored in a computer memory or non-transitory computer readable storage medium (e.g., memory 206 of computer system 102 in FIG. 2). The computer readable storage medium optionally (and typically) includes a magnetic or optical disk storage device, solid state storage devices such as Flash memory, or other non-volatile memory device or devices. The computer readable instructions stored on the computer readable storage medium typically include one or more of: source code, assembly language code, object code, or other instruction format that is interpreted or executed by one or more processors. In various embodiments, some operations in method 400 are combined and/or the order of some operations is changed from the order shown in FIGS. 4A-4E.

A computer system (e.g., computer system 102 in FIGS. 1-2) detects (402) a request, received from a requestor (e.g., an internal requestor 108 or an external requestor 110 in FIG. 1), to access a first data object stored in a tiered data structure (e.g., tiered data structure 104 in FIGS. 1 and 3A), the tiered data structure stored in one or more memory devices, wherein the tiered data structure includes a plurality of internal (non-leaf) nodes (e.g., nodes between a root node and the leaf nodes in the tiered data structure) and a plurality of leaf nodes. For example, when the tiered data structure is a B-Tree or B-Tree like structure (e.g., a B+ tree or a B* tree, or the like) that includes a root node, two or more internal (parent) nodes, and two or more leaf (external child) nodes. In a B-Tree, the topmost node is sometimes called the root node. In a B-Tree, an internal node (also known as an inner node, or inode for short, parent node or branch node) is any node of the B-Tree that has child nodes other than the root node. Similarly, in a B-Tree, a leaf node (also known as an outer node, external node, or terminal node) is any node that does not have child nodes.

In some circumstances, two or more of the leaf nodes each include (404) multiple data objects, each of the data objects including unique key information (e.g., a unique key or information from which a unique key can be identified such as a shortened key and a location/length of a key prefix) and a corresponding value. In some embodiments, the corresponding value is data. In some embodiments, the corresponding value is a pointer identifying a location where the data is stored. In some embodiments, the data objects are contiguous data objects where the unique key information for a respective contiguous data object is adjacent or substantially adjacent to the corresponding value for the respective contiguous data object or other data for the respective contiguous data object that is adjacent to the corresponding value. In some embodiments, the data objects are split data objects where the unique key information for a respective split data object is separated from the corresponding value for the respective split data object by other data for other data objects and the unique key information for the respective split data object is stored with a pointer that identifies a location of the corresponding value for the respective split data object.

In response to detecting the request to access the first data object, the computer system determines (406) whether the first data object is stored in a cache (e.g., data object cache portion 106-1 in FIGS. 1 and 3B) that includes a plurality of data objects from the tiered data structure. The data objects stored in the cache are stored separately from the leaf node to which they correspond in the tiered data structure (e.g., such that a first data object can be retrieved from the cache without retrieving a leaf node that includes data objects that are adjacent to the first data object and without traversing through one or more internal nodes of the tiered data structure). In some embodiments, some or all of the cache is in memory of the computer system. In some embodiments some or all of the cache is remote from the computer system and the cache is (operatively) in communication with the computer system via one or more communication systems.

In some embodiments, the cache is stored (410) in high-speed memory (e.g., RAM or other non-persistent memory with a high read/write rate that loses stored information when power is shut off to the memory, or even high-speed persistent memory). In some circumstances, high-speed persistent memory is more expensive than slower persistent memory and thus the amount of high-speed persistent memory is smaller than the amount of slower persistent memory, so as to reduce device cost. In some embodiments, the tiered data structure is stored in persistent memory that has a slower average read and/or write speed than the high-speed memory (e.g., wherein the persistent memory comprises Flash memory, any suitable three-dimensional non-volatile memory such as vertical NAND, RRAM (also called ReRAM), etc.; hard drive disks, or other persistent memory that maintains its state even when power is shut off to the memory). In some embodiments, the cache is populated (412) with data objects retrieved by traversing the tiered data structure in response to prior requests to access data objects from the tiered data structure.

After determining whether the first data object is stored in the cache, in accordance with a determination that the first data object is stored in the cache, the computer system returns (414) the first data object from the cache to the requestor. For example, data object 25 is retrieved from data object cache portion 106-1 in response to request 2 in FIG. 3B, as described in greater detail above. In some circumstances, even when the first data object is stored in the cache, one or more other data objects included in the leaf node for the first data object are not included in the cache (e.g., because those data objects are not frequently used data objects). For example in FIG. 3B, leaf node 306-2 and data objects 26-30 (which are stored in leaf node 306-2 along with data object 25) are not stored in data object cache portion 106-1, even though data object 25 is stored in data object cache portion 106-1. Forgoing storing some data objects from one or more leaf nodes instead of storing the whole leaf node improves the utility of the cache because more of the frequently used data objects can be stored in the cache than if full leaf nodes were stored in the cache, because less frequently used data objects that happen to reside in the same leaf node as more frequently used objects do not need to be stored in the cache. In many circumstances (e.g., where frequently used data objects are distributed among a large number of leaf nodes), storing frequently used data objects in the cache separately from their corresponding leaf nodes effectively increases the size of the cache, as less unnecessary information is stored in the cache.

In some embodiments, returning the first data object from the cache to the requestor includes locating (416) the first data object in the cache using a hash table to map a unique key of the first data object that is included with the request to a portion of the cache (sometimes referred to as a “bucket”) that includes the first data object (and, optionally, one or more other data objects which have unique keys that are mapped to the portion of the cache by the hash table). In some embodiments, returning the first data object from the cache to the requestor includes locating (418) the first data object in the cache without reference to the tiered data structure (e.g., without traversing the tiered data structure and without retrieving the leaf node that includes the first data object). In some embodiments, the cache has a predefined size, at a respective point in time, the cache is populated with recently accessed data objects for a plurality of leaf nodes (e.g., in response to prior requests to access the data objects) and the predefined size of the cache is smaller (420) than the aggregate size of the plurality of leaf nodes. For example, more data objects are stored in the cache than could be stored in the cache if each of the data objects was stored with its corresponding leaf node. Thus, in some embodiments, separately caching data objects enables a larger number of recently used data objects to be stored in the cache than would be able to be stored if full leaf nodes were cached, as described above with reference to FIG. 3B. In some embodiments, the respective point in time is a point in time after (422) one or more data objects have been evicted from the cache (e.g., the cache has reached a maximum capacity and one or more least recently used objects, including the one or more evicted data objects, have been being evicted from the cache to make room for more recently used objects).

After determining whether the first data object is stored in the cache, in accordance with a determination that the first data object is not stored (424) in the cache (e.g., because a search for the first data object in the cache failed to find the first data object in the cache), the computer system traverses (426) the tiered data structure to a leaf node that includes the first data object. In some embodiments, in conjunction with traversing the tiered data structure to the leaf node for the first data object, the computer system caches (428) internal nodes that are traversed between a root node and the leaf node for the first data object. For example in FIG. 3B, internal node 304-4 is cached after being used to retrieve data object 70 in response to request 3. In some embodiments, the nodes are cached in the same cache as the data objects (e.g., cache 106 in FIGS. 1 and 3B). In some embodiments, the nodes are cached in a node cache (e.g., node cache portion 106-2 in FIGS. 1 and 3B) that is separate from the data object cache (e.g., data object cache portion 106-1 in FIGS. 1 and 3B) used for the data objects. In some embodiments, the leaf node for the first data object is also cached. In some embodiments, the node cache is smaller than the data object cache. In some embodiments, the node cache can store a smaller number of nodes than the data object cache can store data objects. The node cache is, optionally, governed by a least recently used (LRU) cache eviction policy so that when new nodes are stored in the node cache, the least recently used nodes in the node cache are evicted to make room for the new nodes. In some embodiments, traversing the tiered data structure to the leaf node for the first data object includes retrieving (430) one or more nodes that were previously cached (e.g., stored in a node portion of the cache or in a separate node cache) during previous traversals of the tiered data structure (e.g., in response to prior requests to access data objects). For example, in FIG. 3B, internal nodes 304-1 and 304-3 are used to respond to request 1.

After traversing the tiered data structure, the computer system returns (432) the first data object from the leaf node for the first data object in the tiered data structure to the requestor. In some embodiments, in accordance with a determination that the first data object is not stored in the cache, after returning the first data object from the leaf node for the first data object, the computer system stores (434) the first data object in the cache. In some embodiments, in conjunction with storing the first data object in the cache, in accordance with a determination that cache eviction criteria have been met, the computer system evicts (435) one or more other data objects from the cache (e.g., evicting the least recently used data objects in accordance with a least recently used (LRU) cache eviction policy or evicting the oldest data objects in accordance with a first in first out (FIFO) cache eviction policy). In some embodiments, the computer system also caches (436) the leaf node for the first data object in the cache. For example, in FIG. 3B, leaf node 306-4 that includes data object 61 is cached in node cache portion 106-2 when data object 61 is retrieved and cached in data object cache portion 106-1.

In some embodiments, the cache has a data object portion (e.g., data object cache portion 106-1 in FIGS. 1 and 3B) for storing data objects separately from their corresponding leaf nodes and a node portion (e.g., node cache portion 106-2 in FIGS. 1 and 3B) for storing leaf nodes and internal nodes of the tiered data structure. In some embodiments, in conjunction with returning the first data object from the leaf node for the first data object in the tiered data structure to the requestor (e.g., when the first data object is not stored in the cache), the computer system caches (438) the first data object in the data object portion of the cache and caches the leaf node for the first data object in the node portion of the cache. After caching the first data object and the leaf node for the first data object, the computer system accesses (440) a different data object in a different leaf node of the tiered data structure (e.g., in response to detecting a request to access the different data object received from the requestor or another, different, requestor). In conjunction with accessing the different data object, the computer system caches (442) the different data object in the data object portion of the cache while maintaining the first data object in the data object portion of the cache and caches (444) the different leaf node in the node portion of the cache and evicts the leaf node for the first data object from the node portion of the cache. In some embodiments, the leaf node for the first data object is evicted before caching the different leaf node to make room for the different leaf node. For example in FIG. 3B, in response to request 3, leaf node 306-3 is evicted from node cache portion 106-2, while data object 58 (which is from leaf node 306-3) remains in data object cache portion 106-1.

In some circumstances, the computer system detects (446) an insert request to insert a second data object into the tiered data structure. In some embodiments, in response (448) to detecting the insert request, the computer system traverses (450) the tiered data structure to a leaf node for the second data object and inserting the second data object into the leaf node for the second data object (e.g., the leaf node for the first data object or another leaf node that is different from the leaf node for the first data object). In some embodiments, inserting the second data object in the tiered data structure causes a leaf node and optionally one or more internal nodes to be split. In some embodiments, in accordance with a determination that the second data object was successfully inserted into the tiered data structure, the computer system stores (452) the second data object in the cache separately from the leaf node for the second data object. In some embodiments, if the second data object is not successfully inserted into the tiered data structure, the computer system forgoes storing the second data object in the cache (e.g., the second data object is not stored in the cache) and an error message is optionally sent to the requestor indicating that the second data object was not inserted.

In some circumstances, the computer system detects (454) an update request to update a third data object in the tiered data structure. In some embodiments, in response (456) to detecting the update request, the computer system traverses (458) the tiered data structure to a leaf node for the third data object and updating the third data object in the leaf node for the third data object (e.g., the leaf node for the first data object or another leaf node that is different from the leaf node for the first data object). In some embodiments, in accordance with a determination that the third data object was successfully updated in the tiered data structure, the computer system stores (460) the updated third object in the cache separately from the leaf node for the third data object. In some embodiments, if the third data object is not successfully updated in the tiered data structure, the computer system forgoes updating the third data object in the cache (e.g., the third data object is not updated in the cache) and an error message is optionally sent to the requestor indicating that the third data object was not updated. In some embodiments, if a prior version of the third data object is already in the cache, then storing the updated third object in the cache includes updating/replacing the prior version of the third data object in the cache with the updated third object, whereas if a prior version of the third object is not stored in the cache, the updated third object is stored in the cache without needing to delete or overwrite a prior version of the third object.

In some circumstances, the computer system detects (462) a delete request to delete a fourth data object in the tiered data structure. In some embodiments, in response (464) to detecting the delete request, the computer system traverses (466) the tiered data structure to a leaf node for the fourth data object and deleting the fourth data object from the leaf node for the fourth data object (e.g., the leaf node for the first data object or another leaf node that is different from the leaf node for the first data object). In some embodiments, deleting the fourth data object in the tiered data structure causes two or more leaf nodes and, optionally, two or more internal nodes to be combined. In some embodiments, in accordance with a determination that the fourth data object was successfully deleted in the tiered data structure and is stored in the cache, the computer system deletes (468) the fourth object from the cache. In some embodiments, if the fourth data object is not successfully deleted from the tiered data structure, the computer system forgoes deleting the fourth data object from the cache (e.g., the fourth data object is not deleted from the cache) and an error message is optionally sent to the requestor indicating that the fourth data object was not deleted. In situations where the fourth object is not stored in the cache (e.g., in accordance with a determination that the fourth object is not in the cache), the fourth object does not need to be deleted from the object cache.

It should be understood that the particular order in which the operations in FIGS. 4A-4E have been described is merely exemplary and is not intended to indicate that the described order is the only order in which the operations could be performed. One of ordinary skill in the art would recognize various ways to reorder the operations described herein. Additionally, it should be noted that details of other processes described herein with respect to other methods described herein (e.g., methods 500 and 600) are also applicable in an analogous manner to method 400 described above with respect to FIGS. 4A-4E. For example, the tiered data structures, data objects, nodes, and unique key information, described above with reference to method 400 optionally have one or more of the characteristics of the tiered data structures, data objects, nodes, and unique key information described herein with reference to other methods described herein (e.g., method 500 and 600). For brevity, these details are not repeated here.

Attention is now directed to FIGS. 5A-5C, which illustrate a method 500 for performing conditional updates for reducing frequency of data modification operations (e.g., in a tiered data structure), in accordance with some embodiments. Method 500 is, optionally, governed by instructions that are stored in a non-transitory computer readable storage medium and that are executed by one or more processors of one or more computer systems (e.g., computer system 102, FIG. 2). Each of the operations shown in FIGS. 5A-5C typically corresponds to instructions stored in a computer memory or non-transitory computer readable storage medium (e.g., memory 206 of computer system 102 in FIG. 2). The computer readable storage medium optionally (and typically) includes a magnetic or optical disk storage device, solid state storage devices such as Flash memory, or other non-volatile memory device or devices. The computer readable instructions stored on the computer readable storage medium typically include one or more of: source code, assembly language code, object code, or other instruction format that is interpreted or executed by one or more processors. In various embodiments, some operations in method 500 are combined and/or the order of some operations is changed from the order shown in FIGS. 5A-5C.

A computer system (e.g., computer system 102 in FIGS. 1-2) detects (502) a request, received from a requestor (e.g., an internal requestor 108 or an external requestor 110 in FIG. 1), to access a first data object stored in a tiered data structure (e.g., tiered data structure 104 in FIGS. 1 and 3A), the tiered data structure stored in one or more memory devices, wherein the tiered data structure includes a plurality of internal (non-leaf) nodes (e.g., nodes between a root node and the leaf nodes in the tiered data structure) and a plurality of leaf nodes. For example, when the tiered data structure is a B-Tree or B-Tree like structure (e.g., a B+ tree or a B* tree, or the like) that includes a root node, two or more internal (parent) nodes, and two or more leaf (external child) nodes. In a B-Tree, the topmost node is sometimes called the root node. In a B-Tree, an internal node (also known as an inner node, inode for short, parent node or branch node) is any node of the B-Tree that has child nodes other than the root node. Similarly, in a B-Tree, a leaf node (also known as an outer node, external node, or terminal node) is any node that does not have child nodes.

In some circumstances, two or more of the leaf nodes each include (504) multiple data objects, each of the data objects including unique key information (e.g., a unique key or information from which a unique key can be identified such as a shortened key and a location/length of a key prefix) and a corresponding value. In some embodiments, the corresponding value is data. In some embodiments, the corresponding value is a pointer identifying a location where the data is stored. In some embodiments, the data objects are contiguous data objects where the unique key information for a respective contiguous data object is adjacent or substantially adjacent to the corresponding value for the respective contiguous data object or other data for the respective contiguous data object that is adjacent to the corresponding value. In some embodiments, the data objects are split data objects where the unique key information for a respective split data object is separated from the corresponding value for the respective split data object by other data for other data objects and the unique key information for the respective split data object is stored with a pointer that identifies a location of the corresponding value for the respective split data object. In some embodiments, the request to access a first data object comprises (506) a conditional request to modify the first data object (e.g., a request that may or may not result in modifying the first data object depending on one or more conditions such as the current value of the first data object).

In some embodiments, the computer system performs (508) one or more operations in response to detecting the request to access the first data object. The computer system retrieves (510) a leaf node that includes the first data object. In some embodiments, retrieving the leaf node includes traversing (512) the tiered data structure by navigating through one or more internal nodes to the leaf node that includes the first data object, and after traversing through the one or more internal nodes, the computer system read-locks (514) the one or more internal nodes that were traversed to reach the leaf node that includes the first data object. In response to detecting the request to access the first data object, the computer system also locks (516) the leaf node that includes the first data object. In some embodiments, the leaf node that includes the first data object is write-locked (518) while the first conditional-update communication is transmitted and the response is received. For example, in FIG. 3C, leaf node 306-4 is write locked while the conditional-update communication is transmitted and the response is received

In order to improve the efficiency of performing the conditional update operation, the computer system performs a plurality of operations while the leaf node that includes the first data object is locked. In particular, while the leaf node that includes the first data object is (520) locked, the computer system transmits (522), to the requestor, a first conditional-update communication that includes an indication of the current value of the first data object. In some embodiments, the conditional-update communication includes (524) an executable callback object.

After transmitting the first conditional-update communication, the computer system detects (526) a first conditional-update response corresponding to the first data object received from the requestor in response to the first conditional-update communication (e.g., based on the indication of the current value of the first data object). In some embodiments, the conditional-update response corresponds (528) to a result generated based on execution of the callback object.

In response to detecting the first conditional-update response corresponding to the first data object, the computer system performs (530) one or more operations based on the first conditional-update response corresponding to the first data object. In some embodiments, the first conditional-update communication provides (532) information that enables the requestor to determine whether or not to update the value of the first data object based on a current value of the first data object and performing the one or more operations based on the first conditional-update response includes determining whether or the conditional-update response includes a request to update the value of the first data object. In accordance with a determination that the first conditional-update response includes a request to update the value of the first data object, the computer system updates (534) the value of the first data object in accordance with the first conditional-update response. In accordance with a determination that the first conditional-update response does not include a request to update the value of the first data object (e.g., the first conditional-update response includes a request to maintain the value of the first data object or the first conditional-update response includes a request to end the update operation for the first data object without requesting that the value of the first data object be updated), the computer system forgoes (536) updating the value of the first data object (e.g., the first conditional-update response corresponding to the first data object enables performance of an update operation that is not a blind update).

In some circumstances, the request to access the first data object identifies (538) a plurality of data objects including the first data object. In some embodiments, while the leaf node that includes the first data object is locked, and after performing the one or more operations based on the first conditional-update response corresponding to the first data object, the computer system transmits (540), to the requestor, a second conditional-update communication that includes an indication of the current value of a second data object in the plurality of data objects. The computer system subsequently detects (542) a second conditional-update response corresponding to the second data object received from the requestor in response to the second conditional-update communication (e.g., based on the indication of the current value of the second data object) and, in response to detecting the second conditional-update response corresponding to the second data object, the computer system performs (544) one or more operations based on the second conditional-update response corresponding to the second data object. In some embodiments, this process is repeated for a number of different data objects in a predefined (key) order until an object is reached that is not in the leaf node that includes the first data object (e.g., as shown above in FIG. 3C with reference to operations 324-326).

After performing the one or more operations based on the first conditional-update response corresponding to the first data object, the computer system unlocks (546) the leaf node that includes the first data object (e.g., so that other read and/or write operations can be performed on the leaf node and/or data objects contained therein. For example, in FIG. 3C, leaf node 306-4 is unlocked in tiered data structure 104 after performing the operations based on the conditional-update response. In some embodiments (e.g., when the request to access the first data object identifies a plurality of data objects including the first data object), the leaf node that includes the first data object is unlocked after performing (548) the one or more operations based on the second conditional-update response corresponding to the second data object. For example, the leaf node that includes the first data object is unlocked in response to a determination that the request to access the first data object does not identify any additional data objects in the leaf node that includes the first data object.

It should be understood that the particular order in which the operations in FIGS. 5A-5C have been described is merely exemplary and is not intended to indicate that the described order is the only order in which the operations could be performed. One of ordinary skill in the art would recognize various ways to reorder the operations described herein. Additionally, it should be noted that details of other processes described herein with respect to other methods described herein (e.g., methods 400 and 600) are also applicable in an analogous manner to method 500 described above with respect to FIGS. 5A-5C. For example, the tiered data structures, data objects, nodes, and unique key information described above with reference to method 500 optionally have one or more of the characteristics of the tiered data structures, data objects, nodes, and unique key information described herein with reference to other methods described herein (e.g., method 400 and 600). For brevity, these details are not repeated here.

Attention is now directed to FIGS. 6A-6D, which illustrate a method 600 for compaction of information in a tiered data structure, in accordance with some embodiments. Method 600 is, optionally, governed by instructions that are stored in a non-transitory computer readable storage medium and that are executed by one or more processors of one or more computer systems (e.g., computer system 102, FIG. 2). Each of the operations shown in FIGS. 6A-6D typically corresponds to instructions stored in a computer memory or non-transitory computer readable storage medium (e.g., memory 206 of computer system 102 in FIG. 2). The computer readable storage medium optionally (and typically) includes a magnetic or optical disk storage device, solid state storage devices such as Flash memory, or other non-volatile memory device or devices. The computer readable instructions stored on the computer readable storage medium typically include one or more of: source code, assembly language code, object code, or other instruction format that is interpreted or executed by one or more processors. In various embodiments, some operations in method 600 are combined and/or the order of some operations is changed from the order shown in FIGS. 6A-6D.

A computer system (e.g., computer system 102 in FIGS. 1-2) detects (602) a request, received from a requestor (e.g., an internal requestor 108 or an external requestor 110 in FIG. 1), to access a first data object stored in a tiered data structure (e.g., tiered data structure 104 in FIGS. 1 and 3A), the tiered data structure stored in one or more memory devices. The tiered data structure includes (604) a plurality of internal (non-leaf) nodes (e.g., nodes between a root node and the leaf nodes in the tiered data structure) and a plurality of leaf nodes. For example, when the tiered data structure is a B-Tree or B-Tree like structure (e.g., a B+ tree or a B* tree, or the like) that includes a root node, two or more internal (parent) nodes, and two or more leaf (external child) nodes. In a B-Tree, the topmost node is sometimes called the root node. In a B-Tree, an internal node (also known as an inner node, inode for short, parent node or branch node) is any node of the B-Tree that has child nodes other than the root node. Similarly, in a B-Tree, a leaf node (also known as an outer node, external node, or terminal node) is any node that does not have child nodes.

Furthermore, two or more of the leaf nodes each include (606) multiple data objects, each of the data objects including unique key information (e.g., a unique key or information from which a unique key can be identified such as a shortened key and a location/length of a key prefix) and a corresponding value. In some embodiments, the corresponding value is data. In some embodiments, the corresponding value is a pointer identifying a location where the data is stored. In some embodiments, the data objects are contiguous data objects where the unique key information for a respective contiguous data object is adjacent or substantially adjacent to the corresponding value for the respective contiguous data object or other data for the respective contiguous data object that is adjacent to the corresponding value. In some embodiments, the data objects are split data objects where the unique key information for a respective split data object is separated from the corresponding value for the respective split data object by other data for other data objects and the unique key information for the respective split data object is stored with a pointer that identifies a location of the corresponding value for the respective split data object. Additionally, the first data object is (608) uniquely identified by a first key. For example, in FIG. 3D, data object 60 relies on a portion of the key K59 of data object 59 is used, in combination with the unique key information K60 for data object 60 to generate a full unique key that uniquely identifies data object 60.

In response to detecting the request to access the first data object, the computer system retrieves (610) a leaf node that includes the first data object. In some embodiments, the data objects in the leaf node are sorted (612) by key in a predefined key order (e.g., the keys of the data objects in the leaf node are either monotonically increasing or monotonically decreasing from a beginning to an end of the leaf node). In some embodiments, each respective data object of a plurality of the data objects in the leaf node, including the first data object, includes metadata (614) that identifies a location of a key prefix for the key corresponding to the respective data object. In some embodiments, the metadata specifies a location (e.g., an offset to the start of the key prefix) and a length of the key prefix in the leaf node (e.g., metadata M60 for data object 60 includes prefix offset information 338 and prefix length information 340 in FIG. 3D). In some embodiments one or more of the data objects in the leaf node have a null prefix and the entire key is included in the metadata for these data objects with null prefixes. In some embodiments, one or more data objects in the leaf node include a full key and thus do not have metadata that identifies a location of a corresponding key prefix. In some embodiments, first metadata for the first data object has (616) a first length (e.g., metadata M61 for data object 61 is type-0 metadata in FIG. 3D) and second metadata for a second data object in the plurality of data objects has a second length (e.g., metadata M60 for data object 60 is type-1 metadata in FIG. 3D) that is different from the first length. In some embodiments, the first metadata has a first metadata format that is different from a second metadata format of the second data object. In some embodiments the first metadata is part of a contiguous first data object where the first metadata, first unique key information and first value are stored as a contiguous sequence of data (e.g., for data object 61, M61, K61 and V61 are stored contiguously in leaf node 306-4 as shown in FIG. 3D) and the second metadata is part of a contiguous second data object where the second metadata, second unique key information and second value are stored as a contiguous sequence of data (e.g., for data object 60, M60, K60 and V60 are stored contiguously in leaf node 306-4 as shown in FIG. 3D).

In some embodiments, the leaf node includes (618) a fixed length header for each of the plurality of data objects (e.g., headers H59, H60, H61, H63, and H66 in FIG. 3D). In some embodiments, the fixed length headers enable binary searching within the plurality of data objects. For each of the plurality of data objects, the fixed length header includes information indentifying a format of metadata included in the data object. In some embodiments, the fixed length header also includes a pointer identifying a location of the data object in the leaf node. In some circumstances, different data objects in the plurality of data objects have different formats of metadata. In some embodiments, the different formats of metadata have different fields and/or different lengths (e.g., so as to increase an amount of data that can be stored in the leaf nodes by using metadata with a reduced size when possible).

In some embodiments, the leaf node, as stored, is compressed. Thus, in some circumstances, when the stored leaf node is retrieved by the computer system it is still compressed. In such circumstances, after retrieving the leaf node and prior to identifying the first data object in the leaf node, the computer system decompresses (620) the leaf node. In some embodiments (e.g., if the content of the leaf node is modified while accessing the leaf node), the leaf node is recompressed after being modified and the compressed, modified, leaf node is stored.

After retrieving the leaf node that includes the first data object and, optionally, decompressing the leaf node, the computer system identifies (622) the first data object in the leaf node. In the process of identifying the first data object in the leaf node, the computer system combines (624) unique key information (e.g., a “shortened” or “truncated” key) of the first data object with a key prefix that is stored separately in the leaf node to generate a combined key. In some embodiments, the key prefix for the first data object is stored (626) as part of a second data object (e.g., as part of the unique key information of the second data information) that is stored before the first data object in predefined order (e.g., a key order) in the leaf node. In some embodiments, the key prefix comprises (628) a predefined portion of a key (or unique key information) of a distinct second data object in the leaf node. For example, to retrieve data object 60 from leaf node 306-4, after leaf node 306-4 is retrieved, metadata M60 for data object 60 is retrieved and used to identify a key prefix that is a portion of key K59 for data object 59 and the key prefix (e.g., a specified portion of K59) is combined with unique key information K60 for data object 60 to generate a full unique key (or combined key) for data object 60, which is then available for comparison with the first key for the requested data object.

In the process of identifying the first data object in the leaf node, the computer system also determines (630) that the combined key matches the first key that uniquely identifies the first data object. In some embodiments, identifying the first data object includes (632) searching through the leaf node for the first data object by comparing the first key with a plurality of candidate keys for candidate data objects in the leaf node. For example, the computer system uses a binary search pattern where a middle key in a range of key values is compared to the first key and then if the first key is greater than the middle key a first subrange above the middle key is searched starting with a key in the middle of the first subrange, but if the first key is less than the middle key, a second subrange that is below the middle key is searched starting with a key in the middle of the second subrange. In some embodiments, a respective candidate key for a respective candidate data object is generated by combining unique key information for the respective candidate data object with a corresponding key prefix for the respective candidate data object to generate the respective candidate key. After identifying the first data object, the computer system provides (634) access to the first data object to the requestor.

In some circumstances, the computer system detects (636) a request to update the first data object in the leaf node. In some embodiments, in response (638) to detecting the request to update the first data object, the computer system updates (640) the value of the first data object, wherein updating the value of the first data object changes a location of the key prefix for the first data object in the leaf node. In some embodiments, updating the value of the first data object causes a change in an offset distance from a predefined point in the leaf node (e.g., an offset from a beginning or ending of the leaf node) to the data object that includes the key prefix for the first data object. In some embodiments, in response (638) to detecting the request to update the first data object, the computer system updates (642) the unique key information corresponding to the first data object to reflect the change in the location of the key prefix for the first data object. While changing the value of the respective data object does not change the key of the first data object, a change in size of the first data object will, in some circumstances, cause one or more data objects to be moved around in the leaf node in accordance with the change in size of the first data object. When data objects are moved around in the leaf node, pointers in one or more headers (e.g., offsets specified by one or more fixed length headers) and/or metadata for data objects (e.g., offsets to one or more the key prefixes) will, in some circumstances, be updated to account for the movement of the data objects in the leaf node.

In some circumstances, the computer system detects (644) a request to insert a new data object in the tiered data structure. In some embodiments, in response (646) to detecting the request to insert the new data object in the tiered data structure, the computer system identifies (648) a respective leaf node, of the plurality of leaf nodes in the tiered data structure, into which the new data object is to be inserted and identifies (650) a position in the respective leaf node that is after a prior data object in the respective leaf node in a predefined order. In some embodiments in response (646) to detecting the request to insert the new data object in the tiered data structure, the computer system determines (652) a prefix for the key of the respective data object based on a comparison between the key of the respective data object with the key of the prior data object and inserts (654) the data object into the respective leaf node along with an indication of a location in the leaf node of the prefix for the key of the respective data object. In some embodiments, the computer system also updates metadata (e.g., prefix information) that identifies a location of a prefix for one or more data objects that are after the new data object in the predefined order (e.g., data objects that point to a key prefix in a data object that is before the new data object in the predefined order). An example of adding a data object to a leaf node is described above in greater detail with reference to FIG. 3F.

In some circumstances, the computer system detects (656) a request to delete a respective data object in the leaf node that is before a subsequent data object in the leaf node, the respective data object having a key. In some embodiments, in response to detecting the request to delete the respective data object, and in accordance with a determination that the subsequent data object relies on a portion of the key of the respective data object as a key prefix for the subsequent data object, the computer system updates (658) the subsequent data object so that metadata of the subsequent data object does not rely on the portion of the key of the respective data object as the key prefix for the subsequent data object (e.g., by including the whole key in the subsequent data object or by relying on a portion of a key of a different data object in the leaf node). An example of deleting a data object from a leaf node is described above in greater detail with reference to FIG. 3E.

It should be understood that the particular order in which the operations in FIGS. 6A-6D have been described is merely exemplary and is not intended to indicate that the described order is the only order in which the operations could be performed. One of ordinary skill in the art would recognize various ways to reorder the operations described herein. Additionally, it should be noted that details of other processes described herein with respect to other methods described herein (e.g., methods 400 and 500) are also applicable in an analogous manner to method 600 described above with respect to FIGS. 6A-6D. For example, the tiered data structures, data objects, nodes, and unique key information described above with reference to method 600 optionally have one or more of the characteristics of the tiered data structures, data objects, nodes, and unique key information described herein with reference to other methods described herein (e.g., method 400 and 500). For brevity, these details are not repeated here.

Semiconductor memory devices include volatile memory devices, such as dynamic random access memory (“DRAM”) or static random access memory (“SRAM”) devices, non-volatile memory devices, such as resistive random access memory (“ReRAM”), electrically erasable programmable read only memory (“EEPROM”), flash memory (which can also be considered a subset of EEPROM), ferroelectric random access memory (“FRAM”), and magnetoresistive random access memory (“MRAM”), and other semiconductor elements capable of storing information. Each type of memory device may have different configurations. For example, flash memory devices may be configured in a NAND or a NOR configuration.

The memory devices can be formed from passive and/or active elements, in any combinations. By way of non-limiting example, passive semiconductor memory elements include ReRAM device elements, which in some embodiments include a resistivity switching storage element, such as an anti-fuse, phase change material, etc., and optionally a steering element, such as a diode, etc. Further by way of non-limiting example, active semiconductor memory elements include EEPROM and flash memory device elements, which in some embodiments include elements containing a charge storage region, such as a floating gate, conductive nanoparticles, or a charge storage dielectric material.

Multiple memory elements may be configured so that they are connected in series or so that each element is individually accessible. By way of non-limiting example, flash memory devices in a NAND configuration (NAND memory) typically contain memory elements connected in series. A NAND memory array may be configured so that the array is composed of multiple strings of memory in which a string is composed of multiple memory elements sharing a single bit line and accessed as a group. Alternatively, memory elements may be configured so that each element is individually accessible (e.g., a NOR memory array). NAND and NOR memory configurations are exemplary, and memory elements may be otherwise configured.

The semiconductor memory elements located within and/or over a substrate may be arranged in two or three dimensions, such as a two dimensional memory structure or a three dimensional memory structure.

In a two dimensional memory structure, the semiconductor memory elements are arranged in a single plane or a single memory device level. Typically, in a two dimensional memory structure, memory elements are arranged in a plane (e.g., in an x-z direction plane) which extends substantially parallel to a major surface of a substrate that supports the memory elements. The substrate may be a wafer over or in which the layer of the memory elements are formed or it may be a carrier substrate which is attached to the memory elements after they are formed. As a non-limiting example, the substrate may include a semiconductor such as silicon.

The memory elements may be arranged in the single memory device level in an ordered array, such as in a plurality of rows and/or columns. However, the memory elements may be arrayed in non-regular or non-orthogonal configurations. The memory elements may each have two or more electrodes or contact lines, such as bit lines and word lines.

A three dimensional memory array is arranged so that memory elements occupy multiple planes or multiple memory device levels, thereby forming a structure in three dimensions (i.e., in the x, y and z directions, where the y direction is substantially perpendicular and the x and z directions are substantially parallel to the major surface of the substrate).

As a non-limiting example, a three dimensional memory structure may be vertically arranged as a stack of multiple two dimensional memory device levels. As another non-limiting example, a three dimensional memory array may be arranged as multiple vertical columns (e.g., columns extending substantially perpendicular to the major surface of the substrate, i.e., in the y direction) with each column having multiple memory elements in each column. The columns may be arranged in a two dimensional configuration (e.g., in an x-z plane), resulting in a three dimensional arrangement of memory elements with elements on multiple vertically stacked memory planes. Other configurations of memory elements in three dimensions can also constitute a three dimensional memory array.

By way of non-limiting example, in a three dimensional NAND memory array, the memory elements may be coupled together to form a NAND string within a single horizontal (e.g., x-z) memory device level. Alternatively, the memory elements may be coupled together to form a vertical NAND string that traverses across multiple horizontal memory device levels. Other three dimensional configurations can be envisioned wherein some NAND strings contain memory elements in a single memory level while other strings contain memory elements which span through multiple memory levels. Three dimensional memory arrays may also be designed in a NOR configuration and in a ReRAM configuration.

Typically, in a monolithic three dimensional memory array, one or more memory device levels are formed above a single substrate. Optionally, the monolithic three dimensional memory array may also have one or more memory layers at least partially within the single substrate. As a non-limiting example, the substrate may include a semiconductor such as silicon. In a monolithic three dimensional array, the layers constituting each memory device level of the array are typically formed on the layers of the underlying memory device levels of the array. However, layers of adjacent memory device levels of a monolithic three dimensional memory array may be shared or have intervening layers between memory device levels.

Then again, two dimensional arrays may be formed separately and then packaged together to form a non-monolithic memory device having multiple layers of memory. For example, non-monolithic stacked memories can be constructed by forming memory levels on separate substrates and then stacking the memory levels atop each other. The substrates may be thinned or removed from the memory device levels before stacking, but as the memory device levels are initially formed over separate substrates, the resulting memory arrays are not monolithic three dimensional memory arrays. Further, multiple two dimensional memory arrays or three dimensional memory arrays (monolithic or non-monolithic) may be formed on separate chips and then packaged together to form a stacked-chip memory device.

Associated circuitry is typically required for operation of the memory elements and for communication with the memory elements. As non-limiting examples, memory devices may have circuitry used for controlling and driving memory elements to accomplish functions such as programming and reading. This associated circuitry may be on the same substrate as the memory elements and/or on a separate substrate. For example, a controller for memory read-write operations may be located on a separate controller chip and/or on the same substrate as the memory elements.

The term “three-dimensional memory device” (or 3D memory device) is herein defined to mean a memory device having multiple memory layers or multiple levels (e.g., sometimes called multiple memory device levels) of memory elements, including any of the following: a memory device having a monolithic or non-monolithic 3D memory array, some non-limiting examples of which are described above; or two or more 2D and/or 3D memory devices, packaged together to form a stacked-chip memory device, some non-limiting examples of which are described above.

One of skill in the art will recognize that this invention is not limited to the two dimensional and three dimensional exemplary structures described but cover all relevant memory structures within the spirit and scope of the invention as described herein and as understood by one of skill in the art.

It will be understood that, although the terms “first,” “second,” etc. may be used herein to describe various elements, these elements should not be limited by these terms. These terms are only used to distinguish one element from another. For example, a first contact could be termed a second contact, and, similarly, a second contact could be termed a first contact, which changing the meaning of the description, so long as all occurrences of the “first contact” are renamed consistently and all occurrences of the second contact are renamed consistently. The first contact and the second contact are both contacts, but they are not the same contact.

The terminology used herein is for the purpose of describing particular embodiments only and is not intended to be limiting of the claims. As used in the description of the embodiments and the appended claims, the singular forms “a”, “an” and “the” are intended to include the plural forms as well, unless the context clearly indicates otherwise. It will also be understood that the term “and/or” as used herein refers to and encompasses any and all possible combinations of one or more of the associated listed items. It will be further understood that the terms “comprises” and/or “comprising,” when used in this specification, specify the presence of stated features, integers, steps, operations, elements, and/or components, but do not preclude the presence or addition of one or more other features, integers, steps, operations, elements, components, and/or groups thereof.

As used herein, the phrase “at least one of A, B and C” is to be construed to require one or more of the listed items, and this phase reads on a single instance of A alone, a single instance of B alone, or a single instance of C alone, while also encompassing combinations of the listed items such as “one or more of A and one or more of B without any of C,” and the like.

As used herein, the term “if” may be construed to mean “when” or “upon” or “in response to determining” or “in accordance with a determination” or “in response to detecting,” that a stated condition precedent is true, depending on the context. Similarly, the phrase “if it is determined [that a stated condition precedent is true]” or “if [a stated condition precedent is true]” or “when [a stated condition precedent is true]” may be construed to mean “upon determining” or “in response to determining” or “in accordance with a determination” or “upon detecting” or “in response to detecting” that the stated condition precedent is true, depending on the context.

The foregoing description, for purpose of explanation, has been described with reference to specific implementations. However, the illustrative discussions above are not intended to be exhaustive or to limit the claims to the precise forms disclosed. Many modifications and variations are possible in view of the above teachings. The implementations were chosen and described in order to best explain principles of operation and practical applications, to thereby enable others skilled in the art. 

What is claimed is:
 1. A method, performed by a computer system having one or more processors and memory, the method comprising: detecting a request, received from a requestor, to access a first data object stored in a tiered data structure, the tiered data structure stored in one or more memory devices, wherein the tiered data structure includes a plurality of internal nodes and a plurality of leaf nodes; in response to detecting the request to access the first data object, determining whether the first data object is stored in a cache that includes a plurality of data objects from the tiered data structure, wherein the data objects stored in the cache are stored separately from the leaf node to which they correspond in the tiered data structure; and after determining whether the first data object is stored in the cache: in accordance with a determination that the first data object is stored in the cache, returning the first data object from the cache to the requestor; and in accordance with a determination that the first data object is not stored in the cache, traversing the tiered data structure to a leaf node that includes the first data object and returning the first data object from the leaf node for the first data object in the tiered data structure to the requestor.
 2. The method of claim 1, wherein two or more of the leaf nodes each include multiple data objects, each of the data objects including unique key information and a corresponding value.
 3. The method of claim 1, wherein: the cache is stored in high-speed memory; and the tiered data structure is stored in persistent memory that has a slower average read and/or write speed than the high-speed memory.
 4. The method of claim 1, comprising, in accordance with a determination that the first data object is not stored in the cache, after returning the first data object from the leaf node for the first data object, storing the first data object in the cache.
 5. The method of claim 4, comprising, in conjunction with storing the first data object in the cache, in accordance with a determination that cache eviction criteria have been met, evicting one or more other data objects from the cache.
 6. The method of claim 1, comprising, in conjunction with traversing the tiered data structure to the leaf node for the first data object, caching internal nodes that are traversed between a root node and the leaf node for the first data object.
 7. The method of claim 1, wherein traversing the tiered data structure to the leaf node for the first data object includes retrieving one or more nodes that were previously cached during previous traversals of the tiered data structure.
 8. The method of claim 1, wherein the cache is populated with data objects retrieved by traversing the tiered data structure in response to prior requests to access data objects from the tiered data structure.
 9. The method of claim 1, further comprising: detecting an insert request to insert a second data object into the tiered data structure; and in response to detecting the insert request: traversing the tiered data structure to a leaf node for the second data object and inserting the second data object into the leaf node for the second data object; and in accordance with a determination that the second data object was successfully inserted into the tiered data structure, storing the second data object in the cache separately from the leaf node for the second data object.
 10. The method of claim 1, comprising: detecting an update request to update a third data object in the tiered data structure; and in response to detecting the update request: traversing the tiered data structure to a leaf node for the third data object and updating the third data object in the leaf node for the third data object; and in accordance with a determination that the third data object was successfully updated in the tiered data structure, storing the updated third object in the cache separately from the leaf node for the third data object.
 11. The method of claim 1, comprising: detecting a delete request to delete a fourth data object in the tiered data structure; and in response to detecting the delete request: traversing the tiered data structure to a leaf node for the fourth data object and deleting the fourth data object from the leaf node for the fourth data object; and in accordance with a determination that the fourth data object was successfully deleted in the tiered data structure and is stored in the cache, deleting the fourth object from the cache.
 12. The method of claim 1, wherein returning the first data object from the cache to the requestor includes locating the first data object in the cache using a hash table to map a unique key of the first data object that is included with the request to a portion of the cache that includes the first data object.
 13. The method of claim 1, wherein returning the first data object from the cache to the requestor includes locating the first data object in the cache without reference to the tiered data structure.
 14. The method of claim 1, wherein: the cache has a predefined size; at a respective point in time, the cache is populated with recently accessed data objects for a plurality of leaf nodes; and the predefined size of the cache is smaller than the aggregate size of the plurality of leaf nodes.
 15. The method of claim 14, wherein the respective point in time is a point in time after one or more data objects have been evicted from the cache.
 16. The method of claim 1, wherein: the cache has a data object portion for storing data objects separately from their corresponding leaf nodes and a node portion for storing leaf nodes and internal nodes of the tiered data structure; and the method includes: in conjunction with returning the first data object from the leaf node for the first data object in the tiered data structure to the requestor: caching the first data object in the data object portion of the cache; and caching the leaf node for the first data object in the node portion of the cache; and after caching the first data object and the leaf node for the first data object, accessing a different data object in a different leaf node of the tiered data structure; and in conjunction with accessing the different data object: caching the different data object in the data object portion of the cache while maintaining the first data object in the data object portion of the cache; and caching the different leaf node in the node portion of the cache and evicting the leaf node for the first data object from the node portion of the cache.
 17. A computer system, comprising: one or more processors; memory; and one or more programs, wherein the one or more programs are stored in the memory and configured to be executed by the one or more processors, the one or more programs including instructions for: detecting a request, received from a requestor, to access a first data object stored in a tiered data structure, the tiered data structure stored in one or more memory devices, wherein the tiered data structure includes a plurality of internal nodes and a plurality of leaf nodes; in response to detecting the request to access the first data object, determining whether the first data object is stored in a cache that includes a plurality of data objects from the tiered data structure, wherein the data objects stored in the cache are stored separately from the leaf node to which they correspond in the tiered data structure; and after determining whether the first data object is stored in the cache: in accordance with a determination that the first data object is stored in the cache, returning the first data object from the cache to the requestor; and in accordance with a determination that the first data object is not stored in the cache, traversing the tiered data structure to a leaf node that includes the first data object and returning the first data object from the leaf node for the first data object in the tiered data structure to the requestor.
 18. The computer system of claim 17, wherein the one or more programs, when executed by the one or more processors, cause the computer system to perform: storing the first data object in the cache after returning the first data object from the leaf node for the first data object and in accordance with a determination that the first data object is not stored in the cache.
 19. The computer system of claim 17, wherein the one or more programs, when executed by the one or more processors, cause the computer system to perform: caching internal nodes that are traversed between a root node and the leaf node for the first data object in conjunction with traversing the tiered data structure to the leaf node for the first data object.
 20. The computer system of claim 17, wherein the one or more programs, when executed by the one or more processors, cause the computer system to perform: detecting an insert request to insert a second data object into the tiered data structure; traversing the tiered data structure to a leaf node for the second data object and inserting the second data object into the leaf node for the second data object in response to detecting the insert request; and storing the second data object in the cache separately from the leaf node for the second data object in accordance with a determination that the second data object was successfully inserted into the tiered data structure.
 21. The computer system of claim 17, wherein the one or more programs, when executed by the one or more processors, cause the computer system to perform: detecting an update request to update a third data object in the tiered data structure; traversing the tiered data structure to a leaf node for the third data object and updating the third data object in the leaf node for the third data object in response to detecting the update request; and storing the updated third object in the cache separately from the leaf node for the third data object in accordance with a determination that the third data object was successfully updated in the tiered data structure.
 22. The computer system of claim 17, wherein the one or more programs, when executed by the one or more processors, cause the computer system to perform: detecting a delete request to delete a fourth data object in the tiered data structure; traversing the tiered data structure to a leaf node for the fourth data object and deleting the fourth data object from the leaf node for the fourth data object in response to detecting the delete request; and deleting the fourth object from the cache in accordance with a determination that the fourth data object was successfully deleted in the tiered data structure and is stored in the cache.
 23. A non-transitory computer readable storage medium storing one or more programs, the one or more programs comprising instructions, which when executed by a computer system with one or more processors, cause the computer system to: detect a request, received from a requestor, to access a first data object stored in a tiered data structure, the tiered data structure stored in one or more memory devices, wherein the tiered data structure includes a plurality of internal nodes and a plurality of leaf nodes; in response to detecting the request to access the first data object, determine whether the first data object is stored in a cache that includes a plurality of data objects from the tiered data structure, wherein the data objects stored in the cache are stored separately from the leaf node to which they correspond in the tiered data structure; and after determining whether the first data object is stored in the cache: in accordance with a determination that the first data object is stored in the cache, return the first data object from the cache to the requestor; and in accordance with a determination that the first data object is not stored in the cache, traverse the tiered data structure to a leaf node that includes the first data object and returning the first data object from the leaf node for the first data object in the tiered data structure to the requestor.
 24. The non-transitory computer readable storage medium of claim 23, wherein the one or more programs, when executed by the one or more processors, cause the computer system to perform: storing the first data object in the cache after returning the first data object from the leaf node for the first data object and in accordance with a determination that the first data object is not stored in the cache.
 25. The non-transitory computer readable storage medium of claim 23, wherein the one or more programs, when executed by the one or more processors, cause the computer system to perform: caching internal nodes that are traversed between a root node and the leaf node for the first data object in conjunction with traversing the tiered data structure to the leaf node for the first data object. 